/* This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
package Modelo;

//~--- non-JDK imports --------------------------------------------------------

import Controlador.Hash;
import Controlador.Tools;

import Controlador.stegsecret.*;

//~--- JDK imports ------------------------------------------------------------



import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Vector;
import java.util.regex.Pattern;

/**
 * Clase concreta de accion que busca informacion oculta en ficheros de imagenes
 */
public class AccionBuscarInfOculta extends Accion {
    /**
     * Ejecuta la busqueda
     */
    public void ejecutar() {
        dameMultiplesFicheros(new File(""), true, 0);
        
        // dameMultiplesFicheros(new File("C:\\aaaaa\\"),true,1);
        printResultados();
    }
    
    /**
     * Ejecuta la busqueda sobre una unidad concreta
     * @param t Directorio o unidad en la que se buscara
     */
    public void ejecutar(String t) {    // Busqueda a partir de un directorio
        dameMultiplesFicheros(new File(t), true, 1);
        
        // dameMultiplesFicheros(new File("C:\\aaaaa\\"),true,1);
    }
    
    /**
     * Metodo recursivo que permite realizar busquedas de varios tipos en la misma pasada por todos los directorios
     *
     * Busca todos los ficheros que cumplen la mascara que se le pasa y los
     * mete en la listaFicheros que se le pasa.
     *
     * @param pathInicial Path inicial de busqueda. Debe ser un directorio que
     * exista y con permisos de lectura.
     * @param mascara Una mascara
     * @param listaFicheros Una lista de ficheros a la que se anaden los File
     * que cumplan la mascara.
     * @param busquedaRecursiva Si la b�squeda debe ser recursiva en todos los
     * subdirectorios por debajo del pathInicial.
     * @param tec Vector de tecnicas para comprobar. Las mascaras que se comprobaran seran estas
     */
    
            public void dameMultiplesFicheros(File directorio_inicial, boolean busquedaRecursiva, int iteracion) {
        String raices[];
        
        if (iteracion == 0) {
            if (System.getProperties().getProperty("os.name").startsWith("Windows")
            || System.getProperties().getProperty("os.name").startsWith("Microsoft")) {
                raices = Tools.obtenerUnidadesWindows();
            } else {
                raices = Tools.obtenerUnidadesLinux();
            }
        } else {
            raices    = new String[1];
            raices[0] = directorio_inicial.getAbsolutePath();
        }
        
        for (int j = 0; j < raices.length; j++) {
            File fichero = new File(raices[j]);
                     
            
            File directorioInicial = new File(fichero.getPath());
            
            if (directorioInicial.isDirectory()) {
                File[] ficheros = directorioInicial.listFiles();
                
                if (ficheros != null) {
                    for (int i = 0; i < ficheros.length; i++) {
                        if (ficheros[i].isDirectory() && busquedaRecursiva) {
                            
                           
                            dameMultiplesFicheros(ficheros[i], busquedaRecursiva, iteracion + 1);
                        } else {
                            stegdetecreglas steg = new stegdetecreglas();
                            
                            
                            // Comprobar si el fichero tiene informacion oculta y meterlo en el vector de resultados.
                            if (steg.hayInfoOculta(ficheros[i].getAbsolutePath(), true, true, true, true, true, true,
                                    true, true, true)) {
                                for (int k = 0; k < steg.numReglasDetectadas(); k++) {
                                   
                                    _resultados.add(new Parametro("" + steg.infoDetectada()[k][1],
                                            ficheros[i].getAbsolutePath()));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}



